//async future
//async是C++11引入的一个函数模板，用于异步执行一个函数，并返回一个std::future对象，表示异步操作的结果
//使用std::async可以方便地进行异步编程，避免手动创建线程和管理线程的麻烦。


#include<iostream>
#include<thread>
#include<future>	//头文件

//async用法
int func()
{
	int i;
	for (i = 0; i < 1000; i++)
	{
		i++;
	}
	return i;
}

int main()
{
	std::future<int> future_result = std::async(std::launch::async, func);	//func会在后台一个线程中执行，结果保存在future_result对象中
	
	std::cout << func() << std::endl;		//第二个func(),普通调用函数
		
	std::cout << future_result.get() << std::endl;		//通过对象.get()获得结果
									//若.get()时，func()还没有执行完，即future_result中还没有保存结果，会等待func()执行完再get结果
	return 0;
}
//两个func()同时运行，类似于多线程，且不需要手动创建线程
/*
结果:
1000
1000
*/







//packaged_task
//在C++中，packaged task是一个类模板，用于将一个可调用对象(如函数、函数对象或Lambda表达式)封装成一个异步操作，并返回一个std:.future对象
//表示异步操作的结果。packaged task可以方便地将一个函数或可调用对象转换成一个异步操作，供其他线程使用。

#include<iostream>
#include<future>
#include<thread>
int func()
{
	int i = 0; 
	for (i = 0; i < 1000; i++)
	{
		i++;
	}
	return i;
}



int main()
{
	std::packaged_task<int()> task(func);	//得到packaged_task对象
	auto future_result = task.get_future();

	//需要手动开启子线程
	std::thread t1(std::move(task));	//运行结果放到future_result对象里面,move左值转换为右值

	std::cout << func() << std::endl;	//主线程

	t1.join();

	std::cout << future_result.get() << std::endl;	//通过.get()获取结果
	return 0;
}
/*
结果:
1000
1000
*/







//promise
//在C++中，promise是一个类模板，用于在一个线程中产生一个值，并在另一个线程中获取这个值
//promise通常与future和async一起使用，用于实现异步编程。


#include<iostream>
#include<thread>
#include<future>    //头文件

void func(std::promise<int>& f)
{
	f.set_value(1000);
}


int main()
{
	std::promise<int> f;		//创建一个promise对象
	auto future_result = f.get_future();

	std::thread t1(func, std::ref(f));		//创建一个线程
	
	t1.join();

	std::cout << future_result.get() << std::endl;	//主线程中获取t1中的1000
	
	return 0;
}

/*
结果:
1000
*/








